Walkthrough

The pull request implements PostgreSQL custom schema support by adding validation for defaultSchema fields in datasources, filtering the field from Prisma output, auto-generating @@Schema attributes when needed, and introducing helper utilities for schema field access. New end-to-end tests verify validation and SQL generation behavior.

Changes

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~25 minutes

• packages/language/src/validators/datasource-validator.ts: Cross-field validation logic requires careful review to ensure error conditions are correctly identified and reported.
• packages/sdk/src/prisma/prisma-schema-generator.ts: Multiple new helper functions and schema attribute auto-generation logic introduce moderate complexity; verify that filtering and default schema derivation work correctly across edge cases.
• Integration between validator and generator: Ensure validation assumptions align with generation behavior.

Possibly related PRs

• feat: postgres custom schema #385: Implements the same PostgreSQL custom-schema feature across datasource validation, @@Schema attribute generation, and schema-aware name mapping.

Poem

🐰 Hops through schemas with delight,
defaultSchema shining bright,
Postgres dances in the dark,
Validation marks its trusty mark!
Custom realms now take their flight!

Pre-merge checks and finishing touches

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

Claude finished @ymc9's task —— View job

Code Review Complete

Reviewing PR #390: "fix: stricter default schema validation and proper transformation to Prisma schema"

Todo List:

• Read and analyze datasource-validator.ts changes
• Review prisma-schema-generator.ts modifications
• Examine test coverage in pg-custom-schema.test.ts
• Provide feedback on code quality and best practices
• Check for potential bugs and security concerns
• Evaluate performance considerations

Overall Assessment: ✅ Strong Implementation

This PR implements stricter validation for PostgreSQL schema configurations and ensures proper transformation to Prisma schema. The changes are well-structured and address important validation gaps.

Key Improvements

🔧 Enhanced Schema Validation (datasource-validator.ts:41-82)

• Cross-field validation: Now validates that defaultSchema is included in the schemas array
• Provider-specific constraints: Properly restricts defaultSchema and schemas to PostgreSQL only
• Type safety: Ensures all schema values are string literals

🔄 Automatic Schema Generation (prisma-schema-generator.ts:193-204)

• Default schema injection: Automatically adds @@schema("public") when schemas is configured but no explicit @@schema attribute exists
• Clean field filtering: Excludes ZModel-specific defaultSchema field from Prisma schema generation

✅ Comprehensive Test Coverage (pg-custom-schema.test.ts)

• Edge case validation: Tests provider restrictions and cross-field validation
• Query verification: Confirms actual SQL queries use correct schema prefixes
• Real-world scenarios: Tests various combinations of schema configurations

Code Quality Review

✅ Strengths

1. Robust Validation Logic

   // packages/language/src/validators/datasource-validator.ts:73-81
   if (defaultSchemaValue && 
       !schemasValue.items.some((e) => getStringLiteral(e) === defaultSchemaValue)) {
       accept('error', `"${defaultSchemaValue}" must be included in the "schemas" array`, {
           node: schemasField,
       });
   }

   • Proper cross-field validation ensures data consistency
   • Clear, actionable error messages

2. Smart Default Handling

   // packages/sdk/src/prisma/prisma-schema-generator.ts:225-228
   private getDefaultPostgresSchemaName(zmodel: Model) {
       const defaultSchemaField = this.getDatasourceField(zmodel, 'defaultSchema');
       return getStringLiteral(defaultSchemaField?.value) ?? 'public';
   }

   • Sensible fallback to 'public' schema
   • Clean separation of concerns with helper methods

3. Comprehensive Error Coverage

   • Tests validate all error conditions
   • SQL query verification ensures runtime correctness

⚠️ Areas for Consideration

1. Error Message Consistency (Minor)

   // Consider standardizing quote usage in error messages
   // Current: '"schemas" is only supported for "postgresql" provider'
   // Could be: 'The "schemas" field is only supported for PostgreSQL provider'

2. Validation Performance (Minor)

   • Line 68: Array validation uses every() and some() which is O(n²) for large schema arrays
   • For typical use cases (< 10 schemas), this is negligible

3. Type Safety Enhancement (Enhancement)

   // packages/sdk/src/prisma/prisma-schema-generator.ts:68
   const NON_PRISMA_DATASOURCE_FIELDS = ['defaultSchema'];
   // Consider: const NON_PRISMA_DATASOURCE_FIELDS = ['defaultSchema'] as const;

Security & Performance Analysis

🔒 Security: No Issues Found

• All user inputs are validated as string literals
• No SQL injection vectors (schema names are validated, not dynamic)
• Proper input sanitization through AST parsing

⚡ Performance: Efficient Implementation

• Validation runs at compile time, not runtime
• Schema generation is one-time during code generation
• Test queries confirm no performance impact on generated SQL

Test Coverage Assessment: Excellent

The test suite covers:

• ✅ Default behavior (lines 6-68)
• ✅ Custom schema configuration (lines 114-158)
• ✅ Error conditions and edge cases (lines 160-214)
• ✅ Partial schema specification (lines 216-260)
• ✅ Both ORM and Query Builder APIs

Missing test coverage (optional enhancements):

• Empty schemas array handling
• Whitespace/special characters in schema names
• Very long schema names (identifier length limits)

Recommendations

1. Consider Adding: Input validation for schema name format (alphanumeric + underscore)
2. Consider Adding: Warning for very long schema names that might hit database limits
3. Low Priority: Standardize error message formatting across validators

Summary

This is a high-quality implementation that significantly improves ZenStack's PostgreSQL schema support. The code is well-structured, properly tested, and addresses real user needs without introducing technical debt or security vulnerabilities.

Verdict: ✅ Ready to merge - This PR enhances functionality while maintaining code quality standards.